import 'dart:io';

class FileUtil {
  /// 复制单个文件
  static Future<void> copyFile(String sourcePath, String destinationPath) async {
    try {
      // 检查源文件是否存在
      final sourceFile = File(sourcePath);
      if (!await sourceFile.exists()) {
        throw FileSystemException('源文件不存在', sourcePath);
      }

      // 创建目标目录（如果不存在）
      final destinationDir = Directory(destinationPath).parent;
      await destinationDir.create(recursive: true);

      // 复制文件（覆盖已存在的文件）
      final copiedFile = await sourceFile.copy(destinationPath);
      print('文件复制成功: ${copiedFile.path}');
    } catch (e) {
      print('文件复制失败: $e');
      rethrow;
    }
  }

  /// 递归复制目录及其内容
  static Future<void> copyDirectory(String sourceDirPath, String destinationDirPath) async {
    try {
      // 检查源目录是否存在
      final sourceDir = Directory(sourceDirPath);
      if (!await sourceDir.exists()) {
        throw FileSystemException('源目录不存在', sourceDirPath);
      }

      // 创建目标目录
      final destinationDir = Directory(destinationDirPath);
      if (!await destinationDir.exists()) {
        await destinationDir.create(recursive: true);
      }

      // 获取源目录中的所有实体（文件和子目录）
      final entities = await sourceDir.list(recursive: false).toList();

      // 遍历并复制每个实体
      for (final entity in entities) {
        final entityType = await FileSystemEntity.type(entity.path);
        final entityName = entity.path.split(Platform.pathSeparator).last;
        final newPath = '${destinationDir.path}${Platform.pathSeparator}$entityName';

        switch (entityType) {
          case FileSystemEntityType.file:
            await copyFile(entity.path, newPath);
            break;
          case FileSystemEntityType.directory:
            await copyDirectory(entity.path, newPath);
            break;
          default:
            print('跳过: ${entity.path}');
            break;
        }
      }

      print('目录复制成功: $destinationDirPath');
    } catch (e) {
      print('目录复制失败: $e');
      rethrow;
    }
  }

  /// 覆盖写入
  static Future<void> writeText(String filePath, String content) async {
    try {
      final file = File(filePath);
      // 创建父目录（如果不存在）
      await file.parent.create(recursive: true);
      // 写入内容（覆盖模式）
      await file.writeAsString(content);
      print('文件写入成功: $filePath');
    } catch (e) {
      print('文件写入失败: $e');
      rethrow;
    }
  }

  /// 追加写入
  static Future<void> appendText(String filePath, String content) async {
    try {
      final file = File(filePath);
      // 追加内容到文件
      await file.writeAsString(content, mode: FileMode.append);
      print('内容追加成功: $filePath');
    } catch (e) {
      print('内容追加失败: $e');
      rethrow;
    }
  }

  /// 递归删除
  static Future<void> deleteDirectory(String directoryPath) async {
    try {
      final dir = Directory(directoryPath);

      if (!await dir.exists()) {
        print('目录不存在，无需删除: $directoryPath');
        return;
      }

      // 遍历目录中的所有实体
      await for (final entity in dir.list(recursive: false)) {
        final type = await FileSystemEntity.type(entity.path);

        switch (type) {
          case FileSystemEntityType.file:
            await File(entity.path).delete(); // 删除文件
            break;
          case FileSystemEntityType.directory:
            await deleteDirectory(entity.path); // 递归删除子目录
            break;
          case FileSystemEntityType.link:
            await entity.delete(); // 删除符号链接
            break;
          default:
            print('跳过未知实体: ${entity.path}');
            break;
        }
      }

      // 删除空目录
      await dir.delete();
      print('目录自定义删除成功: $directoryPath');
    } catch (e) {
      print('自定义删除目录失败: $e');
      rethrow;
    }
  }

  /// 删除空目录
  static Future<void> deleteEmptyDirectory(String directoryPath) async {
    try {
      final dir = Directory(directoryPath);

      // 检查目录是否存在
      if (await dir.exists()) {
        await dir.delete(); // 删除空目录
        print('空目录删除成功: $directoryPath');
      } else {
        print('目录不存在，无需删除: $directoryPath');
      }
    } catch (e) {
      print('删除空目录失败: $e');
      rethrow;
    }
  }

  /// 递归删除非空目录
  static Future<void> deleteDirectoryRecursively(String directoryPath) async {
    try {
      final dir = Directory(directoryPath);

      // 检查目录是否存在
      if (await dir.exists()) {
        await dir.delete(recursive: true); // 递归删除目录
        print('目录递归删除成功: $directoryPath');
      } else {
        print('目录不存在，无需删除: $directoryPath');
      }
    } catch (e) {
      print('递归删除目录失败: $e');
      rethrow;
    }
  }
}
